<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
                      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
    <title>Action Controllers - Zend Framework Manual</title>

    <link href="../css/shCore.css" rel="stylesheet" type="text/css" />
    <link href="../css/shThemeDefault.css" rel="stylesheet" type="text/css" />
    <link href="../css/styles.css" media="all" rel="stylesheet" type="text/css" />
</head>
<body>
<h1>Zend Framework</h1>
<h2>Programmer's Reference Guide</h2>
<ul>
    <li><a href="../en/zend.controller.action.html">Inglês (English)</a></li>
    <li><a href="../pt-br/zend.controller.action.html">Português Brasileiro (Brazilian Portuguese)</a></li>
</ul>
<table width="100%">
    <tr valign="top">
        <td width="85%">
            <table width="100%">
                <tr>
                    <td width="25%" style="text-align: left;">
                    <a href="zend.controller.dispatcher.html">The Dispatcher</a>
                    </td>

                    <td width="50%" style="text-align: center;">
                        <div class="up"><span class="up"><a href="zend.controller.html">Zend_Controller</a></span><br />
                        <span class="home"><a href="manual.html">Programmer's Reference Guide</a></span></div>
                    </td>

                    <td width="25%" style="text-align: right;">
                        <div class="next" style="text-align: right; float: right;"><a href="zend.controller.actionhelpers.html">Action Helpers</a></div>
                    </td>
                </tr>
            </table>
<hr />
<div id="zend.controller.action" class="section"><div class="info"><h1 class="title">Action Controllers</h1></div>
    

    <div class="section" id="zend.controller.action.introduction"><div class="info"><h1 class="title">Introduction</h1></div>
        

        <p class="para">
            <span class="classname">Zend_Controller_Action</span> is an abstract class you may use
            for implementing Action Controllers for use with the Front
            Controller when building a website based on the
            Model-View-Controller (<acronym class="acronym">MVC</acronym>) pattern.
        </p>

        <p class="para">
            To use <span class="classname">Zend_Controller_Action</span>, you will need to
            subclass it in your actual action controller classes (or subclass it
            to create your own base class for action controllers). The most
            basic operation is to subclass it, and create action methods that
            correspond to the various actions you wish the controller to handle
            for your site. <span class="classname">Zend_Controller</span>&#039;s routing and dispatch handling
            will autodiscover any methods ending in &#039;Action&#039; in your class as
            potential controller actions.
        </p>

        <p class="para">
            For example, let&#039;s say your class is defined as follows:
        </p>

        <pre class="programlisting brush: php">
class FooController extends Zend_Controller_Action
{
    public function barAction()
    {
        // do something
    }

    public function bazAction()
    {
        // do something
    }
}
</pre>


        <p class="para">
            The above <em class="emphasis">FooController</em> class (controller
            <em class="emphasis">foo</em>) defines two actions, <em class="emphasis">bar</em> and
            <em class="emphasis">baz</em>.
        </p>

        <p class="para">
            There&#039;s much more that can be accomplished than this, such as custom
            initialization actions, default actions to call should no action (or
            an invalid action) be specified, pre- and post-dispatch hooks, and a
            variety of helper methods. This chapter serves as an overview of the
            action controller functionality
        </p>

        <blockquote class="note"><p><b class="note">Note</b>: <span class="info"><b>Default Behaviour</b><br /></span>
            

            <p class="para">
                By default, the <a href="zend.controller.front.html" class="link">front
                    controller</a> enables the <a href="zend.controller.actionhelpers.html#zend.controller.actionhelpers.viewrenderer" class="link">ViewRenderer</a>
                action helper. This helper takes care of injecting the view
                object into the controller, as well as automatically rendering
                views. You may disable it within your action controller via one
                of the following methods:
            </p>

            <pre class="programlisting brush: php">
class FooController extends Zend_Controller_Action
{
    public function init()
    {
        // Local to this controller only; affects all actions,
        // as loaded in init:
        $this-&gt;_helper-&gt;viewRenderer-&gt;setNoRender(true);

        // Globally:
        $this-&gt;_helper-&gt;removeHelper(&#039;viewRenderer&#039;);

        // Also globally, but would need to be in conjunction with the
        // local version in order to propagate for this controller:
        Zend_Controller_Front::getInstance()
            -&gt;setParam(&#039;noViewRenderer&#039;, true);
    }
}
</pre>


            <p class="para">
                 <span class="methodname">initView()</span>,  <span class="methodname">getViewScript()</span>,
                 <span class="methodname">render()</span>, and  <span class="methodname">renderScript()</span> each
                proxy to the <em class="emphasis">ViewRenderer</em> unless the helper is not
                in the helper broker or the <em class="emphasis">noViewRenderer</em> flag has
                been set.
            </p>

            <p class="para">
                You can also simply disable rendering for an individual view by
                setting the <em class="emphasis">ViewRenderer</em>&#039;s <em class="emphasis">noRender</em>
                flag:
            </p>

            <pre class="programlisting brush: php">
class FooController extends Zend_Controller_Action
{
    public function barAction()
    {
        // disable autorendering for this action only:
        $this-&gt;_helper-&gt;viewRenderer-&gt;setNoRender();
    }
}
</pre>


            <p class="para">
                The primary reasons to disable the <em class="emphasis">ViewRenderer</em> are
                if you simply do not need a view object or if you are not
                rendering via view scripts (for instance, when using an action
                controller to serve web service protocols such as <acronym class="acronym">SOAP</acronym>,
                <acronym class="acronym">XML-RPC</acronym>, or <acronym class="acronym">REST</acronym>). In most cases, you will
                never need to globally disable the <em class="emphasis">ViewRenderer</em>, only
                selectively within individual controllers or actions.
            </p>
        </p></blockquote>
    </div>

    <div class="section" id="zend.controller.action.initialization"><div class="info"><h1 class="title">Object Initialization</h1></div>
        

        <p class="para">
            While you can always override the action controller&#039;s constructor, we
            do not recommend this.  <span class="methodname">Zend_Controller_Action::__construct()</span>
            performs some important tasks, such as registering the request and
            response objects, as well as any custom invocation arguments passed
            in from the front controller. If you must override the constructor,
            be sure to call  <span class="methodname">parent::__construct($request, $response,
            $invokeArgs)</span>.
        </p>

        <p class="para">
            The more appropriate way to customize instantiation is to use the
             <span class="methodname">init()</span> method, which is called as the last task of
             <span class="methodname">__construct()</span>. For example, if you want to connect to
            a database at instantiation:
        </p>

        <pre class="programlisting brush: php">
class FooController extends Zend_Controller_Action
{
    public function init()
    {
        $this-&gt;db = Zend_Db::factory(&#039;Pdo_Mysql&#039;, array(
            &#039;host&#039;     =&gt; &#039;myhost&#039;,
            &#039;username&#039; =&gt; &#039;user&#039;,
            &#039;password&#039; =&gt; &#039;XXXXXXX&#039;,
            &#039;dbname&#039;   =&gt; &#039;website&#039;
        ));
    }
}
</pre>

    </div>

    <div class="section" id="zend.controller.action.prepostdispatch"><div class="info"><h1 class="title">Pre- and Post-Dispatch Hooks</h1></div>
        

        <p class="para">
            <span class="classname">Zend_Controller_Action</span> specifies two methods that may
            be called to bookend a requested action,  <span class="methodname">preDispatch()</span>
            and  <span class="methodname">postDispatch()</span>. These can be useful in a variety of
            ways: verifying authentication and <acronym class="acronym">ACL</acronym>&#039;s prior to running an action
            (by calling  <span class="methodname">_forward()</span> in
             <span class="methodname">preDispatch()</span>, the action will be skipped), for instance, or
            placing generated content in a sitewide template
            ( <span class="methodname">postDispatch()</span>).
        </p>

        <blockquote class="note"><p><b class="note">Note</b>: <span class="info"><b>Usage of init() vs. preDispatch()</b><br /></span>
            

            <p class="para">
                In the <a href="zend.controller.action.html#zend.controller.action.initialization" class="link">previous
                    section</a>, we introduced the  <span class="methodname">init()</span> method, and
                in this section, the  <span class="methodname">preDispatch()</span> method. What is the
                difference between them, and what actions would you take in each?
            </p>

            <p class="para">
                The  <span class="methodname">init()</span> method is primarily intended for extending the
                constructor. Typically, your constructor should simply set object state, and not
                perform much logic. This might include initializing resources used in the controller
                (such as models, configuration objects, etc.), or assigning values retrieved from
                the front controller, bootstrap, or a registry.
            </p>

            <p class="para">
                The  <span class="methodname">preDispatch()</span> method can also be used to set object
                or environmental (e.g., view, action helper, etc.) state, but its primary purpose
                is to make decisions about whether or not the requested action should be dispatched.
                If not, you should then  <span class="methodname">_forward()</span> to another action, or
                throw an exception.
            </p>

            <p class="para">
                Note:  <span class="methodname">_forward()</span> actually will not work correctly when
                executed from  <span class="methodname">init()</span>, which is a formalization of the
                intentions of the two methods.
            </p>
        </p></blockquote>
    </div>

    <div class="section" id="zend.controller.action.accessors"><div class="info"><h1 class="title">Accessors</h1></div>
        

        <p class="para">
            A number of objects and variables are registered with the object,
            and each has accessor methods.
        </p>

        <ul class="itemizedlist">
            <li class="listitem">
                <p class="para">
                    <em class="emphasis">Request Object</em>:  <span class="methodname">getRequest()</span>
                    may be used to retrieve the request object used to call the action.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                    <em class="emphasis">Response Object</em>:
                     <span class="methodname">getResponse()</span> may be used to retrieve the
                    response object aggregating the final response. Some typical
                    calls might look like:
                </p>

                <pre class="programlisting brush: php">
$this-&gt;getResponse()-&gt;setHeader(&#039;Content-Type&#039;, &#039;text/xml&#039;);
$this-&gt;getResponse()-&gt;appendBody($content);
</pre>

            </li>

            <li class="listitem">
                <p class="para">
                    <em class="emphasis">Invocation Arguments</em>: the front
                    controller may push parameters into the router, dispatcher,
                    and action controller. To retrieve these, use
                     <span class="methodname">getInvokeArg($key)</span>; alternatively, fetch the
                    entire list using  <span class="methodname">getInvokeArgs()</span>.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                    <em class="emphasis">Request parameters</em>: The request object
                    aggregates request parameters, such as any <b><tt>_GET</tt></b> or
                    <b><tt>_POST</tt></b> parameters, or user parameters specified in the
                    <acronym class="acronym">URL</acronym>&#039;s path information. To retrieve these, use
                     <span class="methodname">_getParam($key)</span> or
                     <span class="methodname">_getAllParams()</span>. You may also set request
                    parameters using  <span class="methodname">_setParam()</span>; this is useful
                    when forwarding to additional actions.
                </p>

                <p class="para">
                    To test whether or not a parameter exists (useful for
                    logical branching), use  <span class="methodname">_hasParam($key)</span>.
                </p>

                <blockquote class="note"><p><b class="note">Note</b>: 
                    <p class="para">
                         <span class="methodname">_getParam()</span> may take an optional second
                        argument containing a default value to use if the
                        parameter is not set or is empty. Using it eliminates
                        the need to call  <span class="methodname">_hasParam()</span> prior to
                        retrieving a value:
                    </p>

                    <pre class="programlisting brush: php">
// Use default value of 1 if id is not set
$id = $this-&gt;_getParam(&#039;id&#039;, 1);

// Instead of:
if ($this-&gt;_hasParam(&#039;id&#039;) {
    $id = $this-&gt;_getParam(&#039;id&#039;);
} else {
    $id = 1;
}
</pre>

                </p></blockquote>
            </li>
        </ul>
    </div>

    <div class="section" id="zend.controller.action.viewintegration"><div class="info"><h1 class="title">View Integration</h1></div>
        

        <blockquote class="note"><p><b class="note">Note</b>: <span class="info"><b>Default View Integration is Via the ViewRenderer</b><br /></span>
            

            <p class="para">
                The content in this section is only valid when you have explicitly disabled the
                <a href="zend.controller.actionhelpers.html#zend.controller.actionhelpers.viewrenderer" class="link">ViewRenderer</a>.
                Otherwise, you can safely skip over this section.
            </p>
        </p></blockquote>

        <p class="para">
            <span class="classname">Zend_Controller_Action</span> provides a rudimentary and
            flexible mechanism for view integration. Two methods accomplish
            this,  <span class="methodname">initView()</span> and  <span class="methodname">render()</span>; the
            former method lazy-loads the <var class="varname">$view</var> public property, and the
            latter renders a view based on the current requested action, using
            the directory hierarchy to determine the script path.
        </p>

        <div class="section" id="zend.controller.action.viewintegration.initview"><div class="info"><h1 class="title">View Initialization</h1></div>
            

            <p class="para">
                 <span class="methodname">initView()</span> initializes the view object.
                 <span class="methodname">render()</span> calls  <span class="methodname">initView()</span> in
                order to retrieve the view object, but it may be initialized at any time;
                by default it populates the <var class="varname">$view</var> property with a
                <span class="classname">Zend_View</span> object, but any class implementing
                <span class="classname">Zend_View_Interface</span> may be used. If
                <var class="varname">$view</var> is already initialized, it simply returns
                that property.
            </p>

            <p class="para">
                The default implementation makes the following assumption of
                the directory structure:
            </p>

            <pre class="programlisting brush: php">
applicationOrModule/
    controllers/
        IndexController.php
    views/
        scripts/
            index/
                index.phtml
        helpers/
        filters/
</pre>


            <p class="para">
                In other words, view scripts are assumed to be in the
                <var class="filename">/views/scripts/</var> subdirectory, and the
                <var class="filename">/views/</var> subdirectory is assumed to contain sibling
                functionality (helpers, filters). When determining the view
                script name and path, the <var class="filename">/views/scripts/</var> directory
                will be used as the base path, with directories named after the
                individual controllers providing a hierarchy of view scripts.
            </p>
        </div>

        <div class="section" id="zend.controller.action.viewintegration.render"><div class="info"><h1 class="title">Rendering Views</h1></div>
            

            <p class="para">
                 <span class="methodname">render()</span> has the following signature:
            </p>

            <pre class="programlisting brush: php">
string render(string $action = null,
              string $name = null,
              bool $noController = false);
</pre>


            <p class="para">
                 <span class="methodname">render()</span> renders a view script. If no arguments are
                passed, it assumes that the script requested is
                <var class="filename">[controller]/[action].phtml</var> (where
                <var class="filename">.phtml</var> is the value of the <var class="varname">$viewSuffix</var>
                property). Passing a value for <var class="varname">$action</var> will render
                that template in the <var class="filename">/[controller]/</var> subdirectory. To
                override using the <var class="filename">/[controller]/</var> subdirectory, pass
                a <b><tt>TRUE</tt></b> value for <var class="varname">$noController</var>. Finally,
                templates are rendered into the response object; if you wish to render to
                a specific <a href="zend.controller.response.html#zend.controller.response.namedsegments" class="link">named
                    segment</a> in the response object, pass a value to
                <var class="varname">$name</var>.
            </p>

            <blockquote class="note"><p><b class="note">Note</b>: 
                <p class="para">
                    Since controller and action names may contain word delimiter
                    characters such as &#039;_&#039;, &#039;.&#039;, and &#039;-&#039;,  <span class="methodname">render()</span>
                    normalizes these to &#039;-&#039; when determining the script name. Internally,
                    it uses the dispatcher&#039;s word and path delimiters to do this
                    normalization. Thus, a request to
                    <var class="filename">/foo.bar/baz-bat</var> will render the script
                    <var class="filename">foo-bar/baz-bat.phtml</var>. If your action method
                    contains camelCasing, please remember that this will result
                    in &#039;-&#039; separated words when determining the view script
                    file name.
                </p>
            </p></blockquote>

            <p class="para">
                Some examples:
            </p>

            <pre class="programlisting brush: php">
class MyController extends Zend_Controller_Action
{
    public function fooAction()
    {
        // Renders my/foo.phtml
        $this-&gt;render();

        // Renders my/bar.phtml
        $this-&gt;render(&#039;bar&#039;);

        // Renders baz.phtml
        $this-&gt;render(&#039;baz&#039;, null, true);

        // Renders my/login.phtml to the &#039;form&#039; segment of the
        // response object
        $this-&gt;render(&#039;login&#039;, &#039;form&#039;);

        // Renders site.phtml to the &#039;page&#039; segment of the response
        // object; does not use the &#039;my/&#039; subirectory
        $this-&gt;render(&#039;site&#039;, &#039;page&#039;, true);
    }

    public function bazBatAction()
    {
        // Renders my/baz-bat.phtml
        $this-&gt;render();
    }
}
</pre>

        </div>
    </div>

    <div class="section" id="zend.controller.action.utilmethods"><div class="info"><h1 class="title">Utility Methods</h1></div>
        

        <p class="para">
            Besides the accessors and view integration methods,
            <span class="classname">Zend_Controller_Action</span> has several utility methods for
            performing common tasks from within your action methods (or from
            pre- and post-dispatch).
        </p>

        <ul class="itemizedlist">
            <li class="listitem">
                <p class="para">
                     <span class="methodname">_forward($action, $controller = null, $module = null,
                        array $params = null)</span>: perform another action. If
                    called in  <span class="methodname">preDispatch()</span>, the currently
                    requested action will be skipped in favor of the new one.
                    Otherwise, after the current action is processed, the action
                    requested in  <span class="methodname">_forward()</span> will be executed.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                     <span class="methodname">_redirect($url, array $options =
                        array())</span>: redirect to another location. This
                    method takes a <acronym class="acronym">URL</acronym> and an optional set of options. By
                    default, it performs an <acronym class="acronym">HTTP</acronym> 302 redirect.
                </p>

                <p class="para">
                    The options may include one or more of the following:
                </p>

                <ul class="itemizedlist">
                    <li class="listitem">
                        <p class="para">
                            <em class="emphasis">exit:</em> whether or not to exit
                            immediately. If requested, it will cleanly close any
                            open sessions and perform the redirect.
                        </p>

                        <p class="para">
                            You may set this option globally within the
                            controller using the  <span class="methodname">setRedirectExit()</span>
                            accessor.
                        </p>
                    </li>

                    <li class="listitem">
                        <p class="para">
                            <em class="emphasis">prependBase:</em> whether or not to
                            prepend the base <acronym class="acronym">URL</acronym> registered with the request
                            object to the <acronym class="acronym">URL</acronym> provided.
                        </p>

                        <p class="para">
                            You may set this option globally within the
                            controller using the
                             <span class="methodname">setRedirectPrependBase()</span> accessor.
                        </p>
                    </li>

                    <li class="listitem">
                        <p class="para">
                            <em class="emphasis">code:</em> what <acronym class="acronym">HTTP</acronym> code to utilize
                            in the redirect. By default, an <acronym class="acronym">HTTP</acronym> 302 is
                            utilized; any code between 301 and 306 may be used.
                        </p>

                        <p class="para">
                            You may set this option globally within the
                            controller using the
                             <span class="methodname">setRedirectCode()</span> accessor.
                        </p>
                    </li>
                </ul>
            </li>
        </ul>
    </div>

    <div class="section" id="zend.controller.action.subclassing"><div class="info"><h1 class="title">Subclassing the Action Controller</h1></div>
        

        <p class="para">
            By design, <span class="classname">Zend_Controller_Action</span> must be subclassed
            in order to create an action controller. At the minimum, you will
            need to define action methods that the controller may call.
        </p>

        <p class="para">
            Besides creating useful functionality for your web applications, you
            may also find that you&#039;re repeating much of the same setup or
            utility methods in your various controllers; if so, creating a
            common base controller class that extends
            <span class="classname">Zend_Controller_Action</span> could solve such redundancy.
        </p>

        <div class="example" id="zend.controller.action.subclassing.example-call"><div class="info"><p><b>Example #1 Handling Non-Existent Actions</b></p></div>
            

            <div class="example-contents"><p>
                If a request to a controller is made that includes an undefined
                action method,  <span class="methodname">Zend_Controller_Action::__call()</span>
                will be invoked.  <span class="methodname">__call()</span> is, of course,
                <acronym class="acronym">PHP</acronym>&#039;s magic method for method overloading.
            </p></div>

            <div class="example-contents"><p>
                By default, this method throws a
                <span class="classname">Zend_Controller_Action_Exception</span> indicating the
                requested method was not found in the controller. If the method
                requested ends in &#039;Action&#039;, the assumption is that an action was
                requested and does not exist; such errors result in an exception
                with a code of 404. All other methods result in an exception
                with a code of 500. This allows you to easily differentiate
                between page not found and application errors in your error
                handler.
            </p></div>

            <div class="example-contents"><p>
                You should override this functionality if you wish to perform
                other operations. For instance, if you wish to display an error
                message, you might write something like this:
            </p></div>

            <pre class="programlisting brush: php">
class MyController extends Zend_Controller_Action
{
    public function __call($method, $args)
    {
        if (&#039;Action&#039; == substr($method, -6)) {
            // If the action method was not found, render the error
            // template
            return $this-&gt;render(&#039;error&#039;);
        }

        // all other methods throw an exception
        throw new Exception(&#039;Invalid method &quot;&#039;
                            . $method
                            . &#039;&quot; called&#039;,
                            500);
    }
}
</pre>


            <div class="example-contents"><p>
                Another possibility is that you may want to forward on to a
                default controller page:
            </p></div>

            <pre class="programlisting brush: php">
class MyController extends Zend_Controller_Action
{
    public function indexAction()
    {
        $this-&gt;render();
    }

    public function __call($method, $args)
    {
        if (&#039;Action&#039; == substr($method, -6)) {
            // If the action method was not found, forward to the
            // index action
            return $this-&gt;_forward(&#039;index&#039;);
        }

        // all other methods throw an exception
        throw new Exception(&#039;Invalid method &quot;&#039;
                            . $method
                            . &#039;&quot; called&#039;,
                            500);
    }
}
</pre>

        </div>

        <p class="para">
            Besides overriding  <span class="methodname">__call()</span>, each of the
            initialization, utility, accessor, view, and dispatch hook methods
            mentioned previously in this chapter may be overridden in order to
            customize your controllers. As an example, if you are storing your
            view object in a registry, you may want to modify your
             <span class="methodname">initView()</span> method with code resembling the following:
        </p>

        <pre class="programlisting brush: php">
abstract class My_Base_Controller extends Zend_Controller_Action
{
    public function initView()
    {
        if (null === $this-&gt;view) {
            if (Zend_Registry::isRegistered(&#039;view&#039;)) {
                $this-&gt;view = Zend_Registry::get(&#039;view&#039;);
            } else {
                $this-&gt;view = new Zend_View();
                $this-&gt;view-&gt;setBasePath(dirname(__FILE__) . &#039;/../views&#039;);
            }
        }

        return $this-&gt;view;
    }
}
</pre>


        <p class="para">
            Hopefully, from the information in this chapter, you can see the
            flexibility of this particular component and how you can shape it to
            your application&#039;s or site&#039;s needs.
        </p>
    </div>
</div>
        <hr />

            <table width="100%">
                <tr>
                    <td width="25%" style="text-align: left;">
                    <a href="zend.controller.dispatcher.html">The Dispatcher</a>
                    </td>

                    <td width="50%" style="text-align: center;">
                        <div class="up"><span class="up"><a href="zend.controller.html">Zend_Controller</a></span><br />
                        <span class="home"><a href="manual.html">Programmer's Reference Guide</a></span></div>
                    </td>

                    <td width="25%" style="text-align: right;">
                        <div class="next" style="text-align: right; float: right;"><a href="zend.controller.actionhelpers.html">Action Helpers</a></div>
                    </td>
                </tr>
            </table>
</td>
        <td style="font-size: smaller;" width="15%"> <style type="text/css">
#leftbar {
	float: left;
	width: 186px;
	padding: 5px;
	font-size: smaller;
}
ul.toc {
	margin: 0px 5px 5px 5px;
	padding: 0px;
}
ul.toc li {
	font-size: 85%;
	margin: 1px 0 1px 1px;
	padding: 1px 0 1px 11px;
	list-style-type: none;
	background-repeat: no-repeat;
	background-position: center left;
}
ul.toc li.header {
	font-size: 115%;
	padding: 5px 0px 5px 11px;
	border-bottom: 1px solid #cccccc;
	margin-bottom: 5px;
}
ul.toc li.active {
	font-weight: bold;
}
ul.toc li a {
	text-decoration: none;
}
ul.toc li a:hover {
	text-decoration: underline;
}
</style>
 <ul class="toc">
  <li class="header home"><a href="manual.html">Programmer's Reference Guide</a></li>
  <li class="header up"><a href="manual.html">Programmer's Reference Guide</a></li>
  <li class="header up"><a href="reference.html">Zend Framework Reference</a></li>
  <li class="header up"><a href="zend.controller.html">Zend_Controller</a></li>
  <li><a href="zend.controller.quickstart.html">Zend_Controller Quick Start</a></li>
  <li><a href="zend.controller.basics.html">Zend_Controller Basics</a></li>
  <li><a href="zend.controller.front.html">The Front Controller</a></li>
  <li><a href="zend.controller.request.html">The Request Object</a></li>
  <li><a href="zend.controller.router.html">The Standard Router</a></li>
  <li><a href="zend.controller.dispatcher.html">The Dispatcher</a></li>
  <li class="active"><a href="zend.controller.action.html">Action Controllers</a></li>
  <li><a href="zend.controller.actionhelpers.html">Action Helpers</a></li>
  <li><a href="zend.controller.response.html">The Response Object</a></li>
  <li><a href="zend.controller.plugins.html">Plugins</a></li>
  <li><a href="zend.controller.modular.html">Using a Conventional Modular Directory Structure</a></li>
  <li><a href="zend.controller.exceptions.html">MVC Exceptions</a></li>
 </ul>
 </td>
    </tr>
</table>

<script type="text/javascript" src="../js/shCore.js"></script>
<script type="text/javascript" src="../js/shAutoloader.js"></script>
<script type="text/javascript" src="../js/main.js"></script>

</body>
</html>